home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / khpxtab.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-10  |  8.8 KB  |  359 lines
  1. #include <stdlib.h>
  2. #include "khpxtab.h"
  3. #include "editl.h"
  4. #include "image_p.h"
  5.  
  6. #define min(x,y) (x>y)?y:x
  7. #define max(x,y) (x<y)?y:x
  8.  
  9.  
  10. KH_PX_Table::KH_PX_Table(rect coordinates,   // Screen cells
  11.            char* tabName,                // Table name
  12.            char* fName,                  // File for swapping
  13.            char* h,                      // Header text
  14.            int s,                        // Shadow, pixels
  15.            BORDERS b_type,               // Border type
  16.            BORDERS hdr_b_type,           // Border around header
  17.            int res,                      // Resize status
  18.            int hdr_pat,                  // Attention! No window pattern.
  19.  
  20. // Use last 3 arguments for creating new table.
  21.            int fNo,            // Number of fields in table
  22.            char** fields,      // Fields names array
  23.            char** types)       // Fields types array
  24.  
  25.         : KH_AbstractTable(coordinates, fName, h, s,
  26.            /*col*/ -1, /*wid*/ NULL, /*colNum*/ NULL,
  27.            b_type, hdr_b_type, res, /*pat*/ 0, hdr_pat),
  28.        KH_PXTable(tabName, /*idx*/ 0, fNo, fields, types)
  29.     {
  30.     nColumns = getColumnNumber();
  31.     colNumbers = new int[nFlds + 1];
  32.     for(int i = 0; i < nFlds; i++)
  33.     colNumbers[i] = i;
  34.     iColWidth = new int[nFlds + 1];
  35.     for(xCurs = 0; xCurs < nFlds; xCurs++)
  36.     {
  37.     iColWidth[xCurs] = getFieldMaxWidth();
  38.     }
  39.     xCurs = 0;
  40.     }
  41. ///////////////////////////
  42. int KH_PX_Table::getFieldMaxWidth()
  43.     {
  44.     int w;
  45.     char type[46];
  46.     pxErr = PXRecGet(tblHandle, recHandle);
  47.     pxErr = PXFldType(tblHandle, colNumbers[xCurs] + 1, 26, type);
  48.     switch(type[0])
  49.     {
  50.     case '$':
  51.     case 'N': w = 10; break;
  52.     case 'S': w = 5; break;
  53.     case 'D': w = 12; break;
  54.     case 'A': w = atoi(type + 1) + 2; break;
  55.     default: w = 5; break;
  56.     }
  57.     return w;
  58.     }
  59. ///////////////////////////
  60. long KH_PX_Table::RecordNumber()
  61.     {
  62.     return nRecords;
  63.     }
  64. //////////////////////////////
  65. int KH_PX_Table::getColumnNumber()
  66.     {
  67.     return nFlds;          // Number of fields in record
  68.     }
  69. //////////////////////////////
  70. void KH_PX_Table::getFieldName(char* name, int n)
  71.     {
  72.     pxErr = PXFldName(tblHandle, n, 26, name);
  73.     }
  74. //////////////////////////////
  75. void KH_PX_Table::showField(int sx, int x, int y, int flag, int )
  76.     {
  77.     pxErr = PXRecGoto(tblHandle, y + 1);
  78.     pxErr = PXRecGet(tblHandle, recHandle);
  79.     setFld(x + 1);
  80.     char buf[255];
  81.     if(TranslateField(buf) != KH_BLOB)
  82.     {
  83.     rect r = user_screen();
  84.     int endx = r.corner.X < r.origin.X + screenXL(sx + iColWidth[x] - 1)
  85.         ? r.corner.X : r.origin.X + screenXL(sx + iColWidth[x] - 1);
  86.     setviewport(r.origin.X + screenXL(sx + 1),
  87.             r.origin.Y,
  88.             endx, r.corner.Y, 1);
  89.  
  90.     if(flag)
  91.         bar(2, screenYT(y - yStart + 1) + 2,
  92.         endx - 2, screenYT(y - yStart + 2) - 2);
  93.     setcolor(BLACK);
  94.     settextjustify(LEFT_TEXT, CENTER_TEXT);
  95.     outtextxy(0, screenYT(y - yStart + 1) + pScreenSet->cell_height / 2,
  96.         buf);
  97.     setviewport(0, 0, getmaxx(), getmaxy(), 1);
  98.     }
  99.     }
  100. //////////////////////////////
  101. int KH_PX_Table::check_type(int type, char* string)
  102.     {
  103.     if(type == KH_ALL)
  104.     return 1;
  105.     char** endptr;
  106.     if((type & KH_NUMBER) || (type & KH_MONEY))
  107.     {
  108.     strtod(string, endptr);
  109.     if(*endptr - string != strlen(string))
  110.         return 0;
  111.     return 1;
  112.     }
  113.     if(type & KH_STRING)
  114.     {
  115.     return 1;
  116.     }
  117.     if(type & KH_DATE)
  118.     {
  119.     char buf[20];
  120.     strcpy(buf, string);
  121.     buf[2] = '\0';
  122.     int dd = atoi(buf);
  123.     buf[5] = '\0';
  124.     int mm = atoi(buf + 3);
  125.     int yy = atoi(buf + 6);
  126.     TDATE td;
  127.  
  128.     if((pxErr = PXDateEncode(mm, dd, yy, &td)) == PXSUCCESS)
  129.         return 1;
  130.     return 0;
  131.     }
  132.     if(type & KH_SHORT)
  133.     {
  134.     if(strtod(string, endptr) == (short)atoi(string))
  135.         if(*endptr - string == strlen(string))
  136.         return 1;
  137.     return 0;
  138.     }
  139.  
  140.     if(type & KH_BLOB)
  141.     return 1;
  142.     return 0;
  143.     }
  144. //////////////////////////
  145. void KH_PX_Table::editField()
  146.     {
  147.     pxErr = PXRecGoto(tblHandle, yCurs + 1);
  148.     pxErr = PXRecGet(tblHandle, recHandle);
  149.     setFld(colNumbers[xCurs] + 1);
  150.     char buf[255];
  151.     int type;
  152.     rect r = user_screen();
  153.  
  154.     if((type = TranslateField(buf)) != KH_BLOB)
  155.     {
  156.     setviewport(r.origin.X, r.origin.Y, getmaxx(), getmaxy(), 1);
  157.     EditLine* editl
  158.         = new EditLine(loc(0, 0),
  159.               min(iColWidth[colNumbers[xCurs]], rectangle.width() - 3),
  160.           getFieldMaxWidth() - 2, BUTTON_BORDER, 0, 1);
  161.     editl->put_string(buf);
  162.     editl->show();
  163.     do {
  164.          editl->exe();
  165.        } while(!check_type(type, global[global_num]));
  166.  
  167.     strcpy(buf, global[global_num]);
  168.     delete editl;
  169.  
  170.     setviewport(0, 0, getmaxx(), getmaxy(), 1);
  171.  
  172.     r.origin.Y += pScreenSet->cell_height;
  173.     line_table(r);
  174.     KH_PXFLD f(buf);
  175.     switch(type)
  176.         {
  177.         case KH_NUMBER:
  178.         case KH_MONEY:
  179.         f.type = KH_NUMBER;
  180.         f.n = strtod(buf, NULL);
  181.         break;
  182.         case KH_STRING:
  183.         break;
  184.         case KH_DATE:
  185.         buf[2] = '\0';
  186.         int dd = atoi(buf);
  187.         buf[5] = '\0';
  188.         int mm = atoi(buf + 3);
  189.         int yy = atoi(buf + 6);
  190.         TDATE td;
  191.         pxErr = PXDateEncode(mm, dd, yy, &td);
  192.         f.type = KH_DATE;
  193.         f.date = td;
  194.         break;
  195.         case KH_SHORT:
  196.         f.type = KH_SHORT;
  197.         f.sh = atoi(buf);
  198.         break;
  199.         default:         // BLOB put operations are supplied in ASK MANAGER
  200.         break;
  201.         }
  202.     putField(&f);
  203.     pxErr = PXRecUpdate(tblHandle, recHandle);
  204.  
  205.     }
  206.     setfillstyle(SOLID_FILL, WHITE);
  207.  
  208.     showField(xPos, colNumbers[xCurs], yCurs, 1, getFieldType(colNumbers[xCurs], yCurs));
  209.     mouseShowCursor();
  210.     }
  211. //////////////////////////////
  212. int KH_PX_Table::searchField(int ask)
  213.     {
  214.     int ret = 0;
  215.     pxErr = PXRecGoto(tblHandle, yCurs + 1);
  216.     pxErr = PXRecGet(tblHandle, recHandle);
  217.     setFld(colNumbers[xCurs] + 1);
  218.  
  219.     char buf[255];
  220.     int type;
  221.     rect r = user_screen();
  222.  
  223.     if((type = TranslateField(buf)) != KH_BLOB)
  224.     {
  225.     pxErr = PXRecBufEmpty(recHandle);
  226.     if(ask)
  227.         {
  228.         setviewport(r.origin.X, r.origin.Y, getmaxx(), getmaxy(), 1);
  229.         EditLine* editl
  230.         = new EditLine(loc(0, 0),
  231.                   min(iColWidth[colNumbers[xCurs]], rectangle.width() - 3),
  232.           getFieldMaxWidth() - 2, BUTTON_BORDER, 0, 1);
  233.         editl->put_string(buf);
  234.         editl->show();
  235.         do {
  236.          editl->exe();
  237.            } while(!check_type(type, global[global_num]));
  238.  
  239.         setviewport(0, 0, getmaxx(), getmaxy(), 1);
  240.  
  241.         r.origin.Y += pScreenSet->cell_height;
  242.         line_table(r);
  243.  
  244.         strcpy(buf, global[global_num]);
  245.         delete editl;
  246.         mouseShowCursor();
  247.         }
  248.     KH_PXFLD f(buf);
  249.     switch(type)
  250.         {
  251.         case KH_NUMBER:
  252.         case KH_MONEY:
  253.         f.type = KH_NUMBER;
  254.         f.n = strtod(buf, NULL);
  255.         break;
  256.         case KH_STRING:
  257.         break;
  258.         case KH_DATE:
  259.         buf[2] = '\0';
  260.         int dd = atoi(buf);
  261.         buf[5] = '\0';
  262.         int mm = atoi(buf + 3);
  263.         int yy = atoi(buf + 6);
  264.         TDATE td;
  265.         pxErr = PXDateEncode(mm, dd, yy, &td);
  266.         f.type = KH_DATE;
  267.         f.date = td;
  268.         break;
  269.         case KH_SHORT:
  270.         f.type = KH_SHORT;
  271.         f.sh = atoi(buf);
  272.         break;
  273.         default:         // BLOB
  274.         break;
  275.         }
  276.     putField(&f);
  277.     if((pxErr = PXSrchFld(tblHandle, recHandle, fldHandle, SEARCHNEXT))
  278.         == PXSUCCESS)
  279.         {
  280.         pxErr = PXRecNum(tblHandle, &(RECORDNUMBER)yCurs);
  281.         yCurs--;
  282.         yStart = yCurs;
  283.         yPos = 0;
  284.         ret = 1;
  285.         }
  286.     }
  287.     setfillstyle(SOLID_FILL, WHITE);
  288.  
  289.     return ret;
  290.     }
  291. //////////////////////////////
  292. void KH_PX_Table::saveTable()
  293.     {
  294.     pxErr = PXSave();
  295.     }
  296. //////////////////////////////
  297. void KH_PX_Table::insRecord()
  298.     {
  299.     pxErr = PXRecGoto(tblHandle, yCurs + 1);
  300.     pxErr = PXRecBufEmpty(recHandle);
  301.     if(yCurs == nRecords - 1)
  302.     pxErr = PXRecAppend(tblHandle, recHandle);
  303.     else
  304.     pxErr = PXRecInsert(tblHandle, recHandle);
  305.     if(pxErr == PXSUCCESS)
  306.     nRecords++;
  307.     }
  308. //////////////////////////////
  309. void KH_PX_Table::delRecord()
  310.     {
  311.     pxErr = PXRecGoto(tblHandle, yCurs + 1);
  312.     if(yCurs != nRecords - 1 && (pxErr = PXRecDelete(tblHandle)) == PXSUCCESS)
  313.     nRecords--;
  314.     }
  315. //////////////////////////////
  316. void KH_PX_Table::touch(int )
  317.     {
  318.     delete global[0];
  319.     global[0] = strdup(KH_PXTable::fileName);
  320.     global_num = nFlds;
  321.     char buf[255];
  322.     for(int i = 1; i <= global_num; i++)
  323.         {
  324.         setFld(i);
  325.         delete global[i];
  326.         global_i[i] = TranslateField(buf);
  327.         global[i] = strdup(buf);
  328.     }
  329.     delete global[global_num + 1];
  330.     global[global_num + 1] = strdup("KHPXTAB");
  331.     }
  332. //////////////////////////////
  333. /*
  334. void main()
  335.     {
  336.     if(!init_KNOW_HOW())
  337.     return;
  338.     if(PXInit() != PXSUCCESS)
  339.     return;
  340.  
  341.     setfillstyle(SOLID_FILL, pColorSet->colors.BAK_COLOR);
  342.     bar(0, 0, getmaxx(), getmaxy());
  343.  
  344.     KH_PX_Table w(rect(20, 2, 78, 24), "demo.db", "window.pcy",
  345.     "",
  346.     //" KNOW-HOW 4.x",
  347.     3, SHOW_BORDER,
  348.     NO_BORDER, //SHOW_BORDER,
  349.     0, 19);
  350.  
  351.     w.show_window();
  352.     w.exe();
  353.     w.hide();
  354.  
  355.     PXExit();
  356.     close_KNOW_HOW();
  357.     closegraph();
  358.     }
  359. */